home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac 1993 September / September 93.iso / Archives / Utilities / Quicktime / E D T V / remote.c < prev   
Encoding:
C/C++ Source or Header  |  1991-12-05  |  21.3 KB  |  1,033 lines  |  [TEXT/KAHL]
  1. /****************************************************************************/
  2. /*                                                                            */
  3. /*    Application:    E D T V                                                    */
  4. /*                                                                            */
  5. /*    Description:    This file contains all the routines for controlling        */
  6. /*                    how a movie is played and displayed in the window.        */
  7. /*                                                                            */
  8. /*    File:            remote.c                                                */
  9. /*                                                                            */
  10. /*    Files:            about.c        - routines for the about box                */
  11. /*                    EDTV.c        - routines for displaying movies            */
  12. /*                    menu.c        - routines for handling the menu            */
  13. /*                    remote.c    - routines for controlling the movie        */
  14. /*                    EDTV.h        - header file information                    */
  15. /*                                                                            */
  16. /*    Programmer:        Edgar Lee                                                */
  17. /*    Organization:    Apple Computer, Inc.                                    */
  18. /*    Department:        Developer Technical Support, DTS                        */
  19. /*    Language:        C (Think C version 5.0)                                    */
  20. /*    Date Created:    10-26-91                                                */
  21. /*                                                                            */
  22. /****************************************************************************/
  23.  
  24. #include "EDTV.h"
  25.  
  26. #define    MAXBUTTONS        26            /* Total number of buttons/cicn's. */
  27. #define    ACTUALREMOTE    0
  28. #define    MINIREMOTE        1
  29.  
  30. struct buttonType
  31. {
  32.     CIconHandle    icon;
  33.     Rect        rect;
  34. };
  35.  
  36. struct {
  37.     char    s[8];
  38. } gButtonLabel[MAXBUTTONS] =
  39. {
  40.     "\pstill", 
  41.     "\prew", "\pplay B", "\pplay F", "\pff",
  42.     "\pstart", "\pstep B", "\pstep F", "\pend",
  43.     "\pvol-", "\pvol+","\pmovie", "\p",
  44.     "\pmute", "\pPower", "\p", "\p",
  45.     "\p", "\p", "\p", "\p",
  46.     "\p", "\p", "\p", "\prepeat",
  47.     "\p"
  48. };
  49.  
  50. struct buttonType    gButton[MAXBUTTONS];
  51.  
  52. WindowPtr    gRWindow;                /* Window used for displaying the remote control. */
  53. PicHandle    gReadOutPict;            /* Pict of readout display. */
  54. PicHandle    gMiniRemote;            /* Pict of the scaled down remote image. */
  55.  
  56. int            gCurrentMovie = 0;
  57. int            gRemoteSize = ACTUALREMOTE;
  58. int            gLoopSetting = CONTINUOUS_PLAY;
  59.  
  60. /*-------------------------------------------------------------------------------------*/
  61.  
  62. void createRWindow()
  63. {
  64.     Rect    rect;
  65.     int        width, height;
  66.     
  67.     SetRect( &rect, RLEFT, RTOP, RLEFT + RWIDTH, RTOP + RHEIGHT );
  68.     
  69.     gRWindow = NewCWindow( 0L, &rect, "\p", true, rDocProc,
  70.                             (WindowPtr)-1L, false, 0L );
  71.     
  72.     SetPort( gRWindow );
  73.     
  74.     TextFont( geneva );
  75.     TextMode( 0 );
  76.     TextSize( 9 );
  77.         
  78.     initButtons();
  79.         
  80.     gReadOutPict = (PicHandle)GetResource( 'PICT', 137 );
  81.     gMiniRemote = (PicHandle)GetResource( 'PICT', 136 );
  82.     
  83.     OffsetRect( &(**gMiniRemote).picFrame,
  84.                     (**gMiniRemote).picFrame.left, (**gMiniRemote).picFrame.top );
  85.     
  86.     width = (**gReadOutPict).picFrame.right - (**gReadOutPict).picFrame.left;
  87.     height = (**gReadOutPict).picFrame.bottom - (**gReadOutPict).picFrame.top;
  88.     
  89.     SetRect( &(**gReadOutPict).picFrame, (RWIDTH - width) / 2, 38,
  90.                         (RWIDTH - width) / 2 + width, 38 + height );
  91. }
  92.  
  93. /*-------------------------------------------------------------------------------------*/
  94.  
  95. void initButtons()
  96. {
  97.     int        i;
  98.     int        col, row;
  99.     
  100.     for (i = 0; i < MAXBUTTONS; i++)
  101.         gButton[i].icon = GetCIcon( 200 + i );
  102.     
  103.     col = 12;
  104.     row = 10;
  105.     SetRect( &gButton[12].rect, col, row, col + 12, row + 12 );
  106.     
  107.     row += 4;
  108.     col = gRWindow->portRect.right - 40;
  109.     SetRect( &gButton[14].rect, col, row, col + 32, row + 16 );
  110.     
  111.     col -= 38;
  112.     SetRect( &gButton[16].rect, col, row, col + 32, row + 16 );
  113.     
  114.     col -= 38;
  115.     SetRect( &gButton[15].rect, col, row, col + 32, row + 16 );
  116.         
  117.     col = 10;
  118.     row += 90;
  119.     SetRect( &gButton[0].rect, col, row, col + 32, row + 24 );
  120.     SetRect( &gButton[24].rect, col + 36, row, col + 68, row + 24 );
  121.     
  122.     col = gRWindow->portRect.right - 50;
  123.     SetRect( &gButton[11].rect, col, row + 5, col + 32, row + 5 + 16 );
  124.         
  125.     col = 10;
  126.     row += 40;
  127.     
  128.     for (i = 1; i < 9; i++)
  129.     {
  130.         SetRect( &gButton[i].rect, (((i - 1) % 4) * 36) + col,
  131.                         row, (((i - 1) % 4) * 36) + col + 32, row + 24 );
  132.         
  133.         if (i % 4 == 0)
  134.             row += 40;
  135.     }
  136.     
  137.     col = gRWindow->portRect.right - 82;
  138.     row -= 17;
  139.     
  140.     for (i = 17; i < 23; i++)
  141.     {
  142.         if ((i - 17) % 2 == 0)
  143.             row += 20;
  144.             
  145.         SetRect( &gButton[i].rect, (((i - 17) % 2) * 37) + col,
  146.                         row, (((i - 17) % 2) * 37) + col + 32, row + 16 );
  147.     }
  148.     
  149.     col = 14;
  150.     row -= 42;
  151.     SetRect( &gButton[13].rect, col, row, col + 16, row + 16 );
  152.     
  153.     row += 32;
  154.     SetRect( &gButton[9].rect, col, row, col + 20, row + 24 );
  155.     SetRect( &gButton[10].rect, col + 28, row, col + 20 + 28, row + 24 );
  156.     
  157.     SetRect( &gButton[23].rect, gRWindow->portRect.right - 30,
  158.                                 gRWindow->portRect.bottom - 64,
  159.                                  gRWindow->portRect.right - 15,
  160.                                  gRWindow->portRect.bottom - 32 );
  161.                                  
  162.     SetRect( &gButton[25].rect, 12, gRWindow->portRect.bottom - 48,
  163.                      44, gRWindow->portRect.bottom - 14 );
  164. }
  165.  
  166. /*-------------------------------------------------------------------------------------*/
  167.  
  168. void drawRemote()
  169. {
  170.     if (gRemoteSize == ACTUALREMOTE)
  171.         drawActualRemote();
  172.     else
  173.         drawMiniRemote();
  174. }
  175.  
  176. /*-------------------------------------------------------------------------------------*/
  177.  
  178. void drawMiniRemote()
  179. {
  180.     DrawPicture( gMiniRemote, &gRWindow->portRect );
  181. }
  182.  
  183. /*-------------------------------------------------------------------------------------*/
  184.  
  185. void drawActualRemote()
  186. {
  187.     int            i;
  188.     Rect        rect;
  189.     
  190.     SetPort( gRWindow );
  191.     
  192.     useColor( WHITE, BG );
  193.     EraseRect( &gRWindow->portRect );
  194.  
  195.     rect = gRWindow->portRect;
  196.     InsetRect( &rect, 1, 1 );
  197.     rect.top -= 10;
  198.  
  199.     useColor( SLATE, FG );
  200.     PaintRoundRect( &rect, 16, 16 );
  201.  
  202.     InsetRect( &rect, 5, 5 );
  203.     rect.top = 217;
  204.     
  205.     useColor( BLACK, FG );
  206.     PaintRoundRect( &rect, 16, 16 );
  207.  
  208.     for (i = 0; i < MAXBUTTONS; i++ )
  209.     {
  210.         PlotCIcon( &gButton[i].rect, gButton[i].icon );
  211.         
  212.         useColor( MUSTARD, FG );
  213.         
  214.         if (i == 9 || i == 10 || i == 13)
  215.             useColor( BLACK, BG );
  216.         else
  217.             useColor( SLATE, BG );
  218.         
  219.         if (i == 13)
  220.         {
  221.             useColor( RED, FG );
  222.             MoveTo( gButton[i].rect.right + 5, gButton[i].rect.top + 7 );
  223.         }
  224.         else
  225.             MoveTo( gButton[i].rect.left +
  226.                 ((gButton[i].rect.right - gButton[i].rect.left -
  227.                 StringWidth( gButtonLabel[i].s )) / 2),
  228.                 gButton[i].rect.top - 3 );
  229.                 
  230.         DrawString( gButtonLabel[i].s );
  231.         
  232.         if (i == 11)
  233.         {
  234.             MoveTo( gButton[i].rect.left - 8 , gButton[i].rect.top + 11 );
  235.             DrawChar( '1' );
  236.             MoveTo( gButton[i].rect.right + 4 , gButton[i].rect.top + 11 );
  237.             DrawChar( '2' );
  238.         }
  239.     }
  240.     
  241.     DrawPicture( gReadOutPict, &(**gReadOutPict).picFrame );
  242.     
  243.     useColor( BLACK, BG );
  244.     
  245.     MoveTo( 14, 297 );
  246.     DrawString( "\pLevel:" );
  247.     
  248.     MoveTo( gButton[25].rect.right + 8, gButton[25].rect.bottom - 2 );
  249.     DrawString( "\pS y s t e m  Remote" );
  250.     
  251.     drawReadOutText();
  252.     drawCurrentTime();
  253.     drawVolume();
  254.     drawPoster();
  255.     
  256.     useColor( BLACK, FG );
  257.     useColor( WHITE, BG );
  258. }
  259.  
  260. /*-------------------------------------------------------------------------------------*/
  261.  
  262. void drawVolume()
  263. {
  264.     Rect            rect;
  265.     short            volume;
  266.     CIconHandle        icon;
  267.     
  268.     SetPort( gRWindow );
  269.     
  270.     SetRect( &rect, 48, 288, 58, 303 );
  271.     
  272.     if (gMoviesStatus == MOVIE_LOADED || gMoviesStatus == MOVIE_HIDDEN)
  273.     {
  274.         volume = GetMovieVolume( (gCurrentMovie ? gMovie2 : gMovie1) );
  275.     
  276.         if (volume >= 0)
  277.         {
  278.             if (volume > 255)
  279.                     volume = 255;
  280.                     
  281.             volume = ((float)volume / 28.3333) + 0.5;
  282.         }
  283.         else
  284.             volume = -1;
  285.     }
  286.     else
  287.         volume = 0;
  288.         
  289.     icon = GetCIcon( 130 + volume );
  290.     PlotCIcon( &rect, icon );
  291.     DisposHandle( icon );
  292. }
  293.  
  294. /*-------------------------------------------------------------------------------------*/
  295.  
  296. void drawPoster()
  297. {
  298.     Rect                rect;
  299.     PicHandle            poster;
  300.     RgnHandle            rgn;
  301.     extern RgnHandle    gOrigMovieClipRgn;
  302.     
  303.     SetPort( gRWindow );
  304.     
  305.     SetRect( &rect, 68, 292, 120, 328 );
  306.     
  307.     if (gMoviesStatus == NO_MOVIE)
  308.     {
  309.         useColor( BLACK, FG );
  310.         PaintRect( &rect );
  311.     }
  312.     else
  313.     {
  314.         rgn = GetMovieClipRgn( gMovie1 );
  315.         
  316.         SetMovieClipRgn( gMovie1, gOrigMovieClipRgn );
  317.         poster = GetMoviePosterPict( gMovie1 );
  318.  
  319.         if (poster != nil)
  320.         {
  321.             useColor( GREY, FG );
  322.             FrameRect( &rect );
  323.             
  324.             InsetRect( &rect, 3, 3 );
  325.             
  326.             DrawPicture( poster, &rect );
  327.             KillPicture( poster );
  328.         }
  329.         
  330.         SetMovieClipRgn( gMovie1, rgn );
  331.         DisposeRgn( rgn );
  332.     }
  333. }
  334.  
  335. /*-------------------------------------------------------------------------------------*/
  336.  
  337. void drawReadOutText()
  338. {
  339.     int        col, row;
  340.  
  341.     SetPort( gRWindow );
  342.     useColor( RED, FG );
  343.     useColor( BLACK, BG );
  344.     
  345.     col = (**gReadOutPict).picFrame.left + 32;
  346.     row = (**gReadOutPict).picFrame.top + 17;
  347.  
  348.     MoveTo( col, row );
  349.     DrawString( "\pTime" );
  350.  
  351.     MoveTo( RWIDTH - 66, row );
  352.     DrawString( "\pRemaining" );
  353. }
  354.  
  355. /*-------------------------------------------------------------------------------------*/
  356.  
  357. void drawCurrentTime()
  358. {
  359.     int            col, row;
  360.     int            h, m, s;
  361.     char        string[12];
  362.     TimeRecord    tr;
  363.     TimeValue    movie1Secs, movie2Secs;
  364.     
  365.     if (gMoviesStatus == NO_MOVIE || gRemoteSize == MINIREMOTE)
  366.         return;
  367.  
  368.     SetPort( gRWindow );
  369.     
  370.     useColor( WHITE, FG );
  371.     useColor( BLACK, BG );
  372.     
  373.     col = (**gReadOutPict).picFrame.left + 32;
  374.     row = (**gReadOutPict).picFrame.top + 29;
  375.     
  376.     movie1Secs = GetMovieTime( gMovie1, &tr );
  377.     movie1Secs /= tr.scale;
  378.     
  379.     sec2hms( movie1Secs, &h, &m, &s );
  380.     sprintf( string, "%02d:%02d:%02d", h, m, s );
  381.     MoveTo( col, row );
  382.     DrawString( CtoPstr( string ) );
  383.     
  384.     sec2hms( (gMovieDuration / tr.scale) - movie1Secs, &h, &m, &s );
  385.     sprintf( string, "%02d:%02d:%02d", h, m, s );
  386.     MoveTo( (**gReadOutPict).picFrame.right - 58, row );
  387.     DrawString( CtoPstr( string ) );
  388.     
  389.     row += 12;
  390.  
  391.     movie2Secs = GetMovieTime( gMovie2, &tr );
  392.     movie2Secs /= tr.scale;
  393.     
  394.     sec2hms( movie2Secs, &h, &m, &s );
  395.     sprintf( string, "%02d:%02d:%02d", h, m, s );
  396.     MoveTo( col, row );
  397.     DrawString( CtoPstr( string ) );
  398.     
  399.     sec2hms( (gMovieDuration / tr.scale) - movie2Secs, &h, &m, &s );
  400.     sprintf( string, "%02d:%02d:%02d", h, m, s );
  401.     MoveTo( (**gReadOutPict).picFrame.right - 58, row );
  402.     DrawString( CtoPstr( string ) );
  403. }
  404.  
  405. /*-------------------------------------------------------------------------------------*/
  406.  
  407. void redrawRemoteOnClose()
  408. {
  409.     SetPort( gRWindow );
  410.     DrawPicture( gReadOutPict, &(**gReadOutPict).picFrame );
  411.     drawReadOutText();
  412.     drawVolume();
  413.     drawPoster();
  414. }
  415.  
  416. /*-------------------------------------------------------------------------------------*/
  417.  
  418. void sec2hms( secs, h, m, s )
  419. long    secs;
  420. int        *h, *m, *s;
  421. {
  422.     *h = secs / 3600;
  423.     *m = (secs % 3600) / 60;
  424.     *s = (secs % 3600) % 60;
  425. }
  426.  
  427. /*-------------------------------------------------------------------------------------*/
  428.  
  429. void identifyMovies()
  430. {
  431.     Rect    rect;
  432.     int        size;
  433.     extern    WindowPtr    gWindow;
  434.     
  435.     if (gMoviesStatus == MOVIE_LOADED)
  436.     {
  437.         SetPort( gRWindow );
  438.         
  439.         SetPort( gWindow );
  440.         
  441.         useColor( WHITE, FG );
  442.         useColor( BLACK, BG );
  443.         
  444.         TextMode( srcOr );
  445.         
  446.         GetMovieBox( gMovie1, &rect );
  447.         size = (rect.bottom - rect.top) / 2;
  448.         TextSize( size );
  449.         MoveTo( (rect.right - rect.left - CharWidth( '1' )) / 2 + rect.left,
  450.                 (rect.bottom - rect.top + size) / 2 + rect.top );
  451.         DrawChar( '1' );
  452.         
  453.         if (GetMovieActive( gMovie2 ))
  454.         {
  455.             GetMovieBox( gMovie2, &rect );
  456.             size = (rect.bottom - rect.top) / 2;
  457.             TextSize( size );
  458.             MoveTo( (rect.right - rect.left - CharWidth( '2' )) / 2 + rect.left,
  459.                     (rect.bottom - rect.top + size) / 2 + rect.top );
  460.             DrawChar( '2' );
  461.         }
  462.         
  463.         while( Button() );
  464.         
  465.         TextSize( 9 );
  466.         TextMode( 0 );
  467.         
  468.         UpdateMovie( gMovie1 );
  469.         
  470.         if (GetMovieActive( gMovie2 ))
  471.             UpdateMovie( gMovie2 );
  472.             
  473.         SetPort( gRWindow );
  474.     }
  475. }
  476.  
  477. /*-------------------------------------------------------------------------------------*/
  478.  
  479. void doPlay( rate )
  480. long    rate;
  481. {
  482.     if (gMoviesStatus == MOVIE_LOADED)
  483.     {
  484.         if (rate == 0)
  485.         {
  486.             if (gCurrentMovie == 0 || (gCurrentMovie == 1 && GetMovieActive( gMovie2 )))
  487.                 StopMovie( (gCurrentMovie ? gMovie2 : gMovie1) );
  488.         }
  489.         else
  490.         {
  491.             if (gCurrentMovie == 0 || (gCurrentMovie == 1 && GetMovieActive( gMovie2 )))
  492.                 SetMovieRate( (gCurrentMovie ? gMovie2 : gMovie1), Long2Fix( rate ) );
  493.         }
  494.     }
  495.     
  496.     while( Button() )
  497.     {
  498.         MoviesTask( gMovie1, (long)0 );
  499.         MoviesTask( gMovie2, (long)0 );
  500.     }
  501. }
  502.  
  503. /*-------------------------------------------------------------------------------------*/
  504.  
  505. void doGoto( where )
  506. int    where;
  507. {
  508.     if (gMoviesStatus == MOVIE_LOADED);
  509.     {
  510.         if (gCurrentMovie == 0 || (gCurrentMovie == 1 && GetMovieActive( gMovie2 )))
  511.         {
  512.             StopMovie( (gCurrentMovie ? gMovie2 : gMovie1) );
  513.             
  514.             if (where < 0)
  515.                 GoToBeginningOfMovie( (gCurrentMovie ? gMovie2 : gMovie1) );
  516.             else
  517.                 GoToEndOfMovie( (gCurrentMovie ? gMovie2 : gMovie1) );
  518.         }
  519.     }
  520.  
  521.     while( Button() )
  522.     {
  523.         MoviesTask( gMovie1, (long)0 );
  524.         MoviesTask( gMovie2, (long)0 );
  525.     }
  526. }
  527.  
  528. /*-------------------------------------------------------------------------------------*/
  529.  
  530. void doStep( frames )
  531. short    frames;
  532. {
  533.     TimeRecord    tr;
  534.  
  535.     do
  536.     {
  537.         liteLight();
  538.         
  539.         if (gMoviesStatus == MOVIE_LOADED)
  540.         {
  541.             if (gCurrentMovie == 0 || (gCurrentMovie == 1 && GetMovieActive( gMovie2 )))
  542.             {
  543.                 StopMovie( (gCurrentMovie ? gMovie2 : gMovie1) );
  544.                 
  545.                 GetMovieTime( (gCurrentMovie ? gMovie2 : gMovie1), &tr );
  546.                 
  547.                 if (frames > 0)
  548.                 {
  549.                     tr.value.lo += tr.scale;
  550.                     if (tr.value.lo > gMovieDuration)
  551.                     {
  552.                         if (gLoopSetting == CONTINUOUS_PLAY)
  553.                             tr.value.lo = 0;
  554.                         else
  555.                             tr.value.lo = gMovieDuration;
  556.                     }
  557.                 }
  558.                 else
  559.                 {
  560.                     tr.value.lo -= tr.scale;
  561.                     if (tr.value.lo < 0)
  562.                     {
  563.                         if (gLoopSetting == CONTINUOUS_PLAY)
  564.                             tr.value.lo = gMovieDuration;
  565.                         else
  566.                             tr.value.lo = 0;
  567.                     }
  568.                 }
  569.                 
  570.                 SetMovieTime( (gCurrentMovie ? gMovie2 : gMovie1), &tr );
  571.                 
  572.                 MoviesTask( gMovie1, (long)0 );
  573.                 MoviesTask( gMovie2, (long)0 );
  574.                     
  575.                 drawCurrentTime();
  576.             }
  577.         }
  578.         
  579.         dimLight();
  580.     } while( Button() );
  581. }
  582.  
  583. /*-------------------------------------------------------------------------------------*/
  584.  
  585. void doVolume( level )
  586. int level;
  587. {
  588.     short    volume;
  589.  
  590.     SetPort( gRWindow );
  591.  
  592.     do
  593.     {
  594.         liteLight();
  595.         
  596.         if (gMoviesStatus == MOVIE_LOADED || gMoviesStatus == MOVIE_HIDDEN)
  597.         {
  598.             volume = GetMovieVolume( (gCurrentMovie ? gMovie2 : gMovie1) );
  599.             
  600.             if (volume >= 0)
  601.             {
  602.                 if (volume > 255)
  603.                     volume = 255;
  604.                     
  605.                 if (level > 0)
  606.                 {
  607.                     volume += 10;
  608.                     
  609.                     if (volume > 255)
  610.                         volume = 255;
  611.                 }
  612.                 else
  613.                 {
  614.                     volume -= 10;
  615.                     
  616.                     if (volume < 0)
  617.                         volume = 0;
  618.                 }
  619.                 
  620.                 SetMovieVolume( (gCurrentMovie ? gMovie2 : gMovie1), volume );
  621.                 drawVolume();
  622.             }
  623.             
  624.             MoviesTask( gMovie1, (long)0 );
  625.             MoviesTask( gMovie2, (long)0 );
  626.         }
  627.         
  628.         dimLight();
  629.         
  630.     } while( Button() );
  631. }
  632.  
  633. /*-------------------------------------------------------------------------------------*/
  634.  
  635. void toggleMovies( point )
  636. Point    point;
  637. {
  638.     int        i;
  639.         
  640.     gCurrentMovie = 1 - gCurrentMovie;
  641.  
  642.     if (gCurrentMovie == 0)
  643.         i = 211;
  644.     else
  645.         i = 311;
  646.         
  647.     gButton[11].icon = GetCIcon( i );
  648.     useColor( SLATE, FG );
  649.     PaintRect( &gButton[11].rect );
  650.     PlotCIcon( &gButton[11].rect, gButton[11].icon );
  651.     
  652.     drawVolume();
  653.     
  654.     while( Button() );
  655. }
  656.  
  657. /*-------------------------------------------------------------------------------------*/
  658.  
  659. void doMute()
  660. {
  661.     int    volume;
  662.     
  663.     volume = GetMovieVolume( (gCurrentMovie ? gMovie2 : gMovie1) );
  664.     SetMovieVolume( (gCurrentMovie ? gMovie2 : gMovie1), -volume );
  665.  
  666.     drawVolume();
  667.     
  668.     while( Button() )
  669.     {
  670.         MoviesTask( gMovie1, (long)0 );
  671.         MoviesTask( gMovie2, (long)0 );
  672.     }
  673. }
  674.  
  675. /*-------------------------------------------------------------------------------------*/
  676.  
  677. void doEject()
  678. {
  679.     if (gMoviesStatus == MOVIE_LOADED)
  680.     {
  681.         dimLight();
  682.         closeMovie();
  683.         SetPort( gRWindow );
  684.     }
  685.     
  686.     while( Button() );
  687. }
  688.  
  689. /*-------------------------------------------------------------------------------------*/
  690.  
  691. void doLoad()
  692. {
  693.     if (gMoviesStatus == NO_MOVIE)
  694.     {
  695.         selectMovie();
  696.         SetPort( gRWindow );
  697.     }
  698.     
  699.     while( Button() );
  700. }
  701.  
  702. /*-------------------------------------------------------------------------------------*/
  703.  
  704. void doNormal()
  705. {
  706.     Point    pt;
  707.     
  708.     if (gMoviesStatus == MOVIE_LOADED)
  709.     {
  710.         if (gCurrentMovie == 1)
  711.         {
  712.             pt.h = gButton[10].rect.left;
  713.             pt.v = gButton[10].rect.top;
  714.         
  715.             toggleMovies( pt );
  716.         }
  717.         setGridClipRgn( 1 );
  718.     }
  719.     
  720.     while( Button() )
  721.     {
  722.         MoviesTask( gMovie1, (long)0 );
  723.         MoviesTask( gMovie2, (long)0 );
  724.     }
  725. }
  726.  
  727. /*-------------------------------------------------------------------------------------*/
  728.  
  729. void doPiP()
  730. {
  731.     static int    pos = LRSPOT;
  732.     
  733.     do
  734.     {
  735.         if (gMoviesStatus == MOVIE_LOADED)
  736.         {
  737.             setPiPClipRgn( pos );
  738.             pos = (pos + 1) % 5;
  739.             
  740.             MoviesTask( gMovie1, (long)0 );
  741.             MoviesTask( gMovie2, (long)0 );
  742.         }
  743.     } while( Button() );
  744. }
  745.  
  746. /*-------------------------------------------------------------------------------------*/
  747.  
  748. void doMatrix()
  749. {
  750.     static int    div = 2;
  751.         
  752.     do
  753.     {
  754.         if (gMoviesStatus == MOVIE_LOADED)
  755.         {
  756.             setGridClipRgn( div );
  757.         
  758.             if ((div += 1) == 7)
  759.                 div = 2;
  760.             
  761.             MoviesTask( gMovie1, (long)0 );
  762.             MoviesTask( gMovie2, (long)0 );
  763.         }
  764.     } while( Button() );
  765. }
  766.  
  767. /*-------------------------------------------------------------------------------------*/
  768.  
  769. void doSplit()
  770. {
  771.     static int    pos = LSPLIT;
  772.     
  773.     do
  774.     {
  775.         if (gMoviesStatus == MOVIE_LOADED)
  776.         {
  777.             setSplitClipRgn( pos );
  778.             
  779.             pos = (pos + 1) % 4;
  780.             
  781.             MoviesTask( gMovie1, (long)0 );
  782.             MoviesTask( gMovie2, (long)0 );
  783.         }
  784.     } while( Button() );
  785. }
  786.  
  787. /*-------------------------------------------------------------------------------------*/
  788.  
  789. void doMult()
  790. {
  791.     if (gMoviesStatus == MOVIE_LOADED || gMoviesStatus == MOVIE_HIDDEN)
  792.     {
  793.         setStillFrames();
  794.         gMoviesStatus = MOVIE_HIDDEN;
  795.     }
  796.     
  797.     while( Button() );
  798. }
  799.  
  800. /*-------------------------------------------------------------------------------------*/
  801.  
  802. void doSwap()
  803. {
  804.     Movie        tmpMovie;
  805.     TimeValue    tmpTimeValue;
  806.     Boolean        tmpActiveState;
  807.     Fixed        tmpRate;
  808.     int            tmpVolume;
  809.     extern        WindowPtr    gWindow;
  810.     
  811.     if (gMoviesStatus == MOVIE_LOADED && GetMovieActive( gMovie2 ))
  812.     {
  813.         SetPort( gWindow );
  814.         
  815.         tmpMovie = gMovie1;
  816.         gMovie1 = gMovie2;
  817.         gMovie2 = tmpMovie;
  818.     
  819.         tmpTimeValue = GetMovieTime( gMovie1, nil );
  820.         SetMovieTimeValue( gMovie1, GetMovieTime( gMovie2, nil ) );
  821.         SetMovieTimeValue( gMovie2, tmpTimeValue );
  822.         
  823.         tmpActiveState = GetMovieActive( gMovie1 );
  824.         SetMovieActive( gMovie1, GetMovieActive( gMovie2 ) );
  825.         SetMovieActive( gMovie2, tmpActiveState );
  826.         
  827.         tmpRate = GetMovieRate( gMovie1 );
  828.         SetMovieRate( gMovie1, GetMovieRate( gMovie2 ) );
  829.         SetMovieRate( gMovie2, tmpRate );
  830.         
  831.         tmpVolume = GetMovieVolume( gMovie1 );
  832.         SetMovieVolume( gMovie1, GetMovieVolume( gMovie2 ) );
  833.         SetMovieVolume( gMovie2, tmpVolume );
  834.         
  835.         MoviesTask( gMovie1, (long)0 );
  836.         MoviesTask( gMovie2, (long)0 );
  837.     }
  838. }
  839.  
  840. /*-------------------------------------------------------------------------------------*/
  841.  
  842. void toggleLoop()
  843. {
  844.     while( Button() )
  845.     {
  846.         if (gMoviesStatus == MOVIE_LOADED)
  847.         {
  848.             MoviesTask( gMovie1, (long)0 );
  849.             MoviesTask( gMovie2, (long)0 );
  850.         }
  851.     }
  852.  
  853.     gLoopSetting = CONTINUOUS_PLAY - gLoopSetting;
  854.     
  855.     if (gLoopSetting == CONTINUOUS_PLAY)
  856.         gButton[24].icon = GetCIcon( 224 );
  857.     else
  858.         gButton[24].icon = GetCIcon( 324 );
  859.             
  860.     PlotCIcon( &gButton[23].rect, gButton[23].icon );
  861.  
  862. }
  863.  
  864. /*-------------------------------------------------------------------------------------*/
  865.  
  866. void liteLight()
  867. {
  868.     gButton[12].icon = GetCIcon( 312 );
  869.     PlotCIcon( &gButton[12].rect, gButton[12].icon );
  870. }
  871.  
  872. /*-------------------------------------------------------------------------------------*/
  873.  
  874. void dimLight()
  875. {
  876.     gButton[12].icon = GetCIcon( 212 );
  877.     PlotCIcon( &gButton[12].rect, gButton[12].icon );
  878. }
  879.  
  880. /*-------------------------------------------------------------------------------------*/
  881.  
  882. void invertIcon( i )
  883. int    i;
  884. {
  885.     Rect        rect;
  886.     CIconHandle    icon;
  887.     
  888.     SetPort( gRWindow );
  889.     
  890.     icon = gButton[i].icon;
  891.  
  892.     HLock( (**icon).iconData );
  893.     HLock( icon );
  894.  
  895.     (**icon).iconPMap.baseAddr = *(**icon).iconData;
  896.     (**icon).iconMask.baseAddr = (Ptr)&(**icon).iconMaskData;
  897.     
  898.     CopyBits( &(**icon).iconPMap, &gRWindow->portBits,
  899.                 &(**icon).iconPMap.bounds, &gButton[i].rect, notSrcCopy, 0 );
  900.  
  901.     HUnlock( (**icon).iconData );
  902.     HUnlock( icon );
  903. }
  904.  
  905. /*-------------------------------------------------------------------------------------*/
  906.  
  907. void resizeRemote()
  908. {
  909.     SetPort( gRWindow );
  910.  
  911.     if (gRemoteSize == ACTUALREMOTE)
  912.         SizeWindow( gRWindow, RWIDTH, RHEIGHT, true );
  913.     else
  914.         SizeWindow( gRWindow, (**gMiniRemote).picFrame.right,
  915.                     (**gMiniRemote).picFrame.bottom, true );
  916.                     
  917.     InvalRect( &gRWindow->portRect );
  918. }
  919.  
  920. /*-------------------------------------------------------------------------------------*/
  921.  
  922. void doRemoteEvent( point )
  923. Point    point;
  924. {
  925.     int        i;
  926.     Rect    rect;
  927.     
  928.     if (gRemoteSize == MINIREMOTE)
  929.     {
  930.         gRemoteSize = ACTUALREMOTE;
  931.         resizeRemote();
  932.         return;
  933.     }
  934.     
  935.     SetRect( &rect, 68, 292, 120, 328 );
  936.     
  937.     if (PtInRect( point, &rect ))
  938.     {
  939.         identifyMovies();
  940.         return;
  941.     }
  942.     
  943.     for (i = 0; i < MAXBUTTONS; i++)
  944.     {
  945.         if (i == 12)
  946.             continue;
  947.             
  948.         if (PtInRect( point, &gButton[i].rect ))
  949.         {
  950.             SetPort( gRWindow );
  951.             useColor( BLACK, FG );
  952.             useColor( WHITE, BG );
  953.     
  954.             if (gMoviesStatus == MOVIE_HIDDEN
  955.                     && (i < 9 || i > 13) && i != 21 && i != 23 && i != 25)
  956.             {
  957.                 SetMovieActive( gMovie1, true );
  958.                 SetMovieActive( gMovie2, false );
  959.                     
  960.                 gMoviesStatus = MOVIE_LOADED;
  961.             }
  962.             
  963.             liteLight();
  964.             
  965.             if (i != 11)
  966.                 invertIcon( i );
  967.  
  968.             if (i == 0)
  969.                 doPlay( 0 );
  970.             else if (i == 1)
  971.                 doPlay( -2 );
  972.             else if (i == 2)
  973.                 doPlay( -1 );
  974.             else if (i == 3)
  975.                 doPlay( 1 );
  976.             else if (i == 4)
  977.                 doPlay( 2 );
  978.             else if (i == 5)
  979.                 doGoto( -1 );
  980.             else if (i == 6)
  981.                 doStep( -1 );
  982.             else if (i == 7)
  983.                 doStep( 1 );
  984.             else if (i == 8)
  985.                 doGoto( 1 );
  986.             else if (i == 9)
  987.                 doVolume( -1 );
  988.             else if    (i == 10)
  989.                 doVolume( 1 );
  990.             else if (i == 11)
  991.                 toggleMovies( point );
  992.             else if (i == 13)
  993.                 doMute();
  994.             else if (i == 14)
  995.                 quit();
  996.             else if (i == 15)
  997.                 doEject();
  998.             else if (i == 16)
  999.                 doLoad();
  1000.             else if (i == 17)
  1001.                 doNormal();
  1002.             else if (i == 18)
  1003.                 doPiP();
  1004.             else if (i == 19)
  1005.                 doMatrix();
  1006.             else if (i == 20)
  1007.                 doSplit();
  1008.             else if (i == 21)
  1009.                 doMult();
  1010.             else if (i == 22)
  1011.                 doSwap();
  1012.             else if (i == 24)
  1013.                 toggleLoop();
  1014.             
  1015.             SetPort( gRWindow );
  1016.  
  1017.             if (i != 11)
  1018.                 PlotCIcon( &gButton[i].rect, gButton[i].icon );
  1019.                 
  1020.             dimLight();
  1021.             
  1022.             if (i == 23)
  1023.             {
  1024.                 gRemoteSize = MINIREMOTE;
  1025.                 resizeRemote();
  1026.             }
  1027.             else if (i == 25)
  1028.                 doAboutBox();
  1029.             
  1030.             break;
  1031.         }
  1032.     }
  1033. }